import 'dart:io';
import 'package:dio/dio.dart' as dio;
import 'package:flutter/foundation.dart';
import 'package:get/get.dart';
import '../services/dio_service.dart';
import '../models/index.dart';
import '../utils/encryption_util.dart';

/// 用户API调用类
/// 
/// 负责所有用户相关的API调用
/// 使用DioService进行网络请求，返回标准化的ApiResponse
/// 这是一个工具类，不是服务类
class UserApi {
  // 🔗 API路径常量
  static const String sendSmsCodePath = '/users/send_sms_code/';
  static const String loginPath = '/users/check_phone/';
  static const String registerPath = '/users/create_with_phone/';
  static const String updateUserPath = '/users/update/';
  static const String uploadImagePath = '/users/upload_image/';
  static const String filteredContentPath = '/users/filtered_content/';
  static const String realnameAuthPath = '/users/real-name-auth/';
  
  // 📡 网络服务实例
  static DioService get _dioService => Get.find<DioService>();
  
  /// 发送短信验证码（使用AES加密）
  /// 
  /// [userPhone] 手机号
  /// [verificationCode] 验证码（6位数字，前端生成）
  /// 返回发送结果
  static Future<Map<String, dynamic>> sendSmsCode({
    required String userPhone,
    required String verificationCode,
  }) async {
    try {
      debugPrint('🔄 =============== 开始发送短信验证码 ===============');
      debugPrint('📱 手机号: $userPhone');
      debugPrint('🔢 验证码: $verificationCode');
      
      // 构建请求数据
      final requestData = {
        'userPhone': userPhone,
        'userCode': verificationCode,
      };
      
      // 🔥 手动AES加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      // 使用普通 post 方法（不使用 postEncrypted，避免重复加密）
      final response = await _dioService.post(
        sendSmsCodePath,
        data: encryptedPayload,
      );
      
      debugPrint('✅ 短信验证码发送响应: ${response.data}');
      
      // 返回响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        return response.data as Map<String, dynamic>;
      } else {
        return {'status': 'error', 'message': '服务器响应格式错误'};
      }
    } catch (e) {
      debugPrint('❌ 发送短信验证码失败: $e');
      return {'status': 'error', 'message': '发送验证码失败: ${e.toString()}'};
    }
  }
  
  /// 🔥 检查账号是否已注册（与小程序保持一致）
  /// 
  /// 接口: POST /users/check_phone/
  /// 加密方式: AES-256-CBC
  /// 
  /// [userPhone] 手机号
  /// 返回检查结果，包含exists、banned、data等字段
  static Future<Map<String, dynamic>> checkPhone({
    required String userPhone,
  }) async {
    try {
      debugPrint('🔍 =============== 检查账号是否已注册 ===============');
      debugPrint('📱 手机号: $userPhone');
      
      // 构建请求数据
      final requestData = {
        'userPhone': userPhone,
      };
      
      // 🔥 手动AES加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      // 使用普通 post 方法
      final response = await _dioService.post(
        loginPath,
        data: encryptedPayload,
      );
      
      debugPrint('✅ 账号检查响应: ${response.data}');
      
      // 返回完整响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        return response.data as Map<String, dynamic>;
      } else {
        return {'status': 'error', 'message': '服务器响应格式错误'};
      }
    } catch (e) {
      debugPrint('❌ 账号检查失败: $e');
      return {'status': 'error', 'message': '账号检查失败: ${e.toString()}'};
    }
  }
  
  /// 用户登录API（验证码登录 - 使用AES加密）
  /// 
  /// [userPhone] 手机号
  /// 返回包含用户信息的响应
  static Future<UserEntity> login({
    required String userPhone,
  }) async {
    try {
      debugPrint('🔄 =============== 开始用户登录 ===============');
      debugPrint('📱 手机号: $userPhone');
      
      // 构建请求数据
      final requestData = {
        'userPhone': userPhone,
      };
      
      // 🔥 手动AES加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      // 使用普通 post 方法
      final response = await _dioService.post(
        loginPath,
        data: encryptedPayload,
      );
      
      debugPrint('✅ 登录响应: ${response.data}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        // 检查响应状态
        final status = responseData['status']?.toString();
        final exists = responseData['exists'] as bool?;
        
        if (status == 'success' && exists == true) {
          // 成功响应 - 解析data字段为UserProfileModel
          final data = responseData['data'];
          if (data != null && data is Map<String, dynamic>) {
            final userProfile = UserEntity.fromJson(data);
            
            debugPrint('✅ 登录成功: ${userProfile.username}');
            debugPrint('🆔 用户ID: ${userProfile.userid}');
            debugPrint('👥 粉丝数: ${userProfile.userFollowers}');
            
            return userProfile;
          } else {
            debugPrint('❌ 用户数据格式错误');
            throw Exception('用户数据格式错误');
          }
        } else {
          // 业务失败响应
          final message = responseData['message']?.toString() ?? '登录失败';
          debugPrint('❌ 登录失败: $message');
          throw Exception(message);
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ 登录异常: $e');
      rethrow;
    }
  }
  /// 获取用户个人信息API（使用AES加密）
  /// 
  /// 根据手机号获取用户详细信息
  /// 直接返回UserEntity
  static Future<UserEntity> getUserProfile(String userPhone) async {
    try {
      debugPrint('🔄 =============== 开始获取用户个人信息 ===============');
      debugPrint('📱 手机号: $userPhone');
      
      // 构建请求数据
      final requestData = {
        'userPhone': userPhone,
      };
      
      // 🔥 手动AES加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      // 使用普通 post 方法
      final response = await _dioService.post(
        loginPath,
        data: encryptedPayload,
      );
      
      debugPrint('✅ 用户信息查询响应: ${response.data}');
      
      // 解析响应数据（与login方法保持一致的响应格式）
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        // 检查响应状态
        final status = responseData['status']?.toString();
        final exists = responseData['exists'] as bool?;
        
        if (status == 'success' && exists == true) {
          // 成功响应 - 解析data字段为UserProfileModel
          final data = responseData['data'];
          if (data != null && data is Map<String, dynamic>) {
            final userProfile = UserEntity.fromJson(data);
            
            debugPrint('✅ 获取用户个人信息成功: ${userProfile.username}');
            debugPrint('🆔 用户ID: ${userProfile.userid}');
            
            return userProfile;
          } else {
            debugPrint('❌ 用户个人信息数据格式错误');
            throw Exception('用户信息数据格式错误');
          }
        } else {
          // 业务失败响应
          final message = responseData['message']?.toString() ?? '获取用户个人信息失败';
          debugPrint('❌ 获取用户个人信息失败: $message');
          throw Exception(message);
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ 获取用户个人信息异常: $e');
      rethrow;
    }
  }
  
  /// 修改用户个人信息API（使用AES加密）
  /// 
  /// [userPhone] 用户手机号
  /// [userData] 要更新的用户数据
  /// 直接返回更新后的UserEntity
  static Future<UserEntity> updateUserProfile({
    required String userPhone,
    required Map<String, dynamic> userData,
  }) async {
    try {
      debugPrint('🔄 =============== 开始修改用户个人信息 ===============');
      debugPrint('📱 手机号: $userPhone');
      
      // 构建请求数据
      final requestData = {
        'userPhone': userPhone,
        ...userData,
      };
      
      debugPrint('📊 请求参数: $requestData');
      
      // 🔥 手动AES加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      // 使用普通 post 方法
      final response = await _dioService.post(
        updateUserPath,
        data: encryptedPayload,
      );
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        // 🔥 支持两种响应格式
        // 格式1：{code: 200, msg: "xxx", data: {...}}
        // 格式2：{status: "success", message: "xxx", data: {...}}
        
        final code = responseData['code']?.toInt();
        final status = responseData['status']?.toString();
        final msg = responseData['msg']?.toString() ?? responseData['message']?.toString();
        
        // 判断是否成功
        final isSuccess = (code != null && code == 200) || (status == 'success');
        
        if (isSuccess) {
          // 成功响应 - 解析data字段为UserEntity
          final data = responseData['data'];
          if (data != null && data is Map<String, dynamic>) {
            final userProfile = UserEntity.fromJson(data);
            
            debugPrint('✅ 修改用户信息成功: ${userProfile.username}');
            
            return userProfile;
          } else {
            debugPrint('❌ 用户信息数据格式错误');
            throw Exception('用户信息数据格式错误');
          }
        } else {
          // 业务失败响应
          debugPrint('❌ 修改用户信息失败: $msg');
          throw Exception(msg ?? '修改用户信息失败');
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ 修改用户信息异常: $e');
      rethrow;
    }
  }
  
  /// 上传用户头像API（不加密，使用FormData）
  /// 
  /// [userId] 用户ID
  /// [avatarFilePath] 头像文件路径
  /// 返回AvatarUploadResp包含上传结果
  static Future<AvatarUploadResp> uploadAvatar(String avatarFilePath, {int? userId}) async {
    try {
      debugPrint('🔄 开始上传用户头像: $avatarFilePath');
      if (userId != null) {
        debugPrint('👤 用户ID: $userId');
      }
      
      // 检查文件是否存在
      final file = File(avatarFilePath);
      if (!await file.exists()) {
        debugPrint('❌ 头像文件不存在');
        return AvatarUploadResp.failure('头像文件不存在');
      }
      
      // 创建FormData（与小程序保持一致：字段名 'file' + 'user_id'）
      final Map<String, dynamic> formDataMap = {
        'file': await dio.MultipartFile.fromFile(
          avatarFilePath,
          filename: avatarFilePath.split('/').last,
        ),
      };
      
      // 如果提供了 userId，则添加到表单数据
      if (userId != null) {
        formDataMap['user_id'] = userId;
      }
      
      final formData = dio.FormData.fromMap(formDataMap);
      
      debugPrint('🔄 发送头像上传请求（不加密）');
      
      // 发送POST请求（不加密）
      final response = await _dioService.post(
        uploadImagePath,
        data: formData,
        options: dio.Options(
          contentType: 'multipart/form-data',
        ),
      );
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        // 🔥 根据响应格式判断（支持两种响应格式）
        // 格式1：{code: 200, imgUrl: "xxx"}
        // 格式2：{image_url: "xxx"}
        
        final code = responseData['code']?.toInt();
        final imgUrl = responseData['imgUrl']?.toString() ?? responseData['image_url']?.toString();
        final msg = responseData['msg']?.toString();
        
        if (code != null) {
          // 有 code 字段的响应格式
          if (code == 200) {
            if (imgUrl != null && imgUrl.isNotEmpty) {
              debugPrint('✅ 头像上传成功: $imgUrl');
              return AvatarUploadResp.success(imgUrl);
            } else {
              debugPrint('❌ 头像上传响应中没有imgUrl');
              return AvatarUploadResp.failure('服务器响应异常');
            }
          } else {
            debugPrint('❌ 头像上传失败: $msg');
            return AvatarUploadResp.failure(msg ?? '上传头像失败');
          }
        } else {
          // 直接返回 image_url 的响应格式
          if (imgUrl != null && imgUrl.isNotEmpty) {
            debugPrint('✅ 头像上传成功: $imgUrl');
            return AvatarUploadResp.success(imgUrl);
          } else {
            debugPrint('❌ 头像上传响应中没有图片URL');
            return AvatarUploadResp.failure('服务器响应异常');
          }
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        return AvatarUploadResp.failure('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ 头像上传异常: $e');
      return AvatarUploadResp.failure('头像上传异常：${e.toString()}');
    }
  }
  
  /// 用户注册API（使用AES加密）
  /// 
  /// [userPhone] 手机号
  /// [userType] 用户类型："0"=个人用户, "1"=商家用户
  /// 返回注册后的用户信息
  static Future<UserEntity> registerWithPhone({
    required String userPhone,
    String userType = '0',
  }) async {
    try {
      debugPrint('🔄 =============== 开始用户注册 ===============');
      debugPrint('📱 手机号: $userPhone');
      debugPrint('👤 用户类型: $userType');
      
      // 构建请求数据
      final requestData = {
        'userPhone': userPhone,
        'userCode': userType,  // "0"=个人用户, "1"=商家用户
        'GenToken': '1',       // 生成融云token
      };
      
      // 🔥 手动AES加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      // 使用普通 post 方法
      final response = await _dioService.post(
        registerPath,
        data: encryptedPayload,
      );
      
      debugPrint('✅ 注册响应: ${response.data}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        // 检查响应状态
        final status = responseData['status']?.toString();
        
        if (status == 'success') {
          // 成功响应 - 解析data字段为UserEntity
          final data = responseData['data'];
          if (data != null && data is Map<String, dynamic>) {
            final userProfile = UserEntity.fromJson(data);
            
            debugPrint('✅ 注册成功: ${userProfile.username}');
            debugPrint('🆔 用户ID: ${userProfile.userid}');
            debugPrint('🔐 融云Token: ${userProfile.rongcloudToken}');
            
            return userProfile;
          } else {
            debugPrint('❌ 用户数据格式错误');
            throw Exception('用户数据格式错误');
          }
        } else {
          // 业务失败响应
          final message = responseData['message']?.toString() ?? '注册失败';
          debugPrint('❌ 注册失败: $message');
          throw Exception(message);
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        throw Exception('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ 注册异常: $e');
      rethrow;
    }
  }
  
  /// 上传用户图片API（通用图片上传）
  /// 
  /// [userId] 用户ID
  /// [imageFilePath] 图片文件路径
  /// 返回AvatarUploadResp包含上传结果
  static Future<AvatarUploadResp> uploadUserImage({
    required int userId,
    required String imageFilePath,
  }) async {
    try {
      debugPrint('🔄 开始上传用户图片: $imageFilePath');
      debugPrint('👤 用户ID: $userId');
      
      // 检查文件是否存在
      final file = File(imageFilePath);
      if (!await file.exists()) {
        debugPrint('❌ 图片文件不存在');
        return AvatarUploadResp.failure('图片文件不存在');
      }
      
      // 创建FormData
      final formData = dio.FormData.fromMap({
        'file': await dio.MultipartFile.fromFile(
          imageFilePath,
          filename: imageFilePath.split('/').last,
        ),
        'user_id': userId,
      });
      
      debugPrint('🔄 发送图片上传请求');
      
      // 发送POST请求
      final response = await _dioService.post(
        uploadImagePath,
        data: formData,
        options: dio.Options(
          contentType: 'multipart/form-data',
        ),
      );
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        // 获取图片URL
        final imageUrl = responseData['image_url']?.toString();
        
        if (imageUrl != null && imageUrl.isNotEmpty) {
          debugPrint('✅ 图片上传成功: $imageUrl');
          return AvatarUploadResp.success(imageUrl);
        } else {
          debugPrint('❌ 图片上传响应中没有image_url');
          return AvatarUploadResp.failure('服务器响应异常');
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        return AvatarUploadResp.failure('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ 图片上传异常: $e');
      return AvatarUploadResp.failure('图片上传异常：${e.toString()}');
    }
  }
  
  /// 获取用户过滤内容API（查看他人主页）
  /// 
  /// [userId] 目标用户ID
  /// [contentType] 内容类型（'activities' 或 'comments'），默认'activities'
  /// 返回用户过滤内容结果
  static Future<UserFilteredContentResp> getUserFilteredContent({
    required int userId,
    String contentType = 'activities',
  }) async {
    try {
      debugPrint('🔄 =============== 获取用户过滤内容 ===============');
      debugPrint('👤 目标用户ID: $userId');
      debugPrint('📝 内容类型: $contentType');
      
      // 构建请求数据
      final requestData = {
        'userId': userId,
        'content_type': contentType,  // 使用下划线格式
      };
      
      // 🔥 手动AES加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      // 使用普通 post 方法
      final response = await _dioService.post(
        filteredContentPath,
        data: encryptedPayload,
      );
      
      debugPrint('✅ 用户过滤内容响应: ${response.data}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        // 检查响应状态
        final status = responseData['status']?.toString();
        
        if (status == 'success') {
          // 成功响应 - 解析为UserFilteredContentResp
          final result = UserFilteredContentResp.fromJson(responseData);
          
          debugPrint('✅ 获取用户过滤内容成功');
          debugPrint('👤 用户信息: ${result.user?.username}');
          debugPrint('👥 好友数量: ${result.friendCount}');
          if (contentType == 'activities') {
            debugPrint('📊 活动数量: ${result.activities?.length ?? 0}');
          } else if (contentType == 'comments') {
            debugPrint('📊 评论数量: ${result.comments?.length ?? 0}');
          }
          
          return result;
        } else {
          // 业务失败响应
          final message = responseData['message']?.toString() ?? '获取用户内容失败';
          debugPrint('❌ 获取用户过滤内容失败: $message');
          return UserFilteredContentResp.failure(message);
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        return UserFilteredContentResp.failure('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ 获取用户过滤内容异常: $e');
      return UserFilteredContentResp.failure('获取用户内容异常：${e.toString()}');
    }
  }
  
  /// 实名认证API（使用AES加密）
  /// 
  /// 参考小程序实现：wanzhende-m/miniprogram/utils/api.js realnameAuth
  /// 
  /// [userId] 用户ID
  /// [realName] 真实姓名
  /// [idCardNo] 身份证号
  /// 返回实名认证结果
  static Future<RealnameAuthResp> realnameAuth({
    required int userId,
    required String realName,
    required String idCardNo,
  }) async {
    try {
      debugPrint('🔐 =============== 开始实名认证（AES加密） ===============');
      debugPrint('👤 用户ID: $userId');
      debugPrint('📝 姓名: $realName');
      debugPrint('🆔 身份证: ***************'); // 隐藏敏感信息
      
      // 构建请求数据（与小程序完全一致）
      final request = RealnameAuthReq(
        userId: userId,
        realName: realName,
        idCardNo: idCardNo,
      );
      
      final requestData = request.toJson();
      
      debugPrint('📊 请求参数（加密前）: ${requestData['userid']}, ${requestData['name']}, ***');
      
      // 🔥 使用AES加密
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      debugPrint('🚀 准备发送加密请求到: $realnameAuthPath');
      
      // 发送POST请求
      final response = await _dioService.post(
        realnameAuthPath,
        data: encryptedPayload,
      );
      
      debugPrint('✅ 实名认证响应: ${response.data}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        // 检查响应状态
        final status = responseData['status']?.toString();
        
        if (status == 'success') {
          // 成功响应 - 解析为RealnameAuthResp
          final result = RealnameAuthResp.fromJson(responseData);
          
          debugPrint('✅ 实名认证成功: ${result.message}');
          debugPrint('🔐 认证状态: verified=${result.verified}, authStatus=${result.authStatus}');
          
          return result;
        } else {
          // 业务失败响应
          final message = responseData['message']?.toString() ?? '实名认证失败';
          debugPrint('❌ 实名认证失败: $message');
          return RealnameAuthResp.failure(message);
        }
      } else {
        debugPrint('❌ 服务器响应格式错误');
        return RealnameAuthResp.failure('服务器响应格式错误');
      }
    } catch (e) {
      debugPrint('❌ 实名认证异常: $e');
      return RealnameAuthResp.failure('实名认证异常：${e.toString()}');
    }
  }
  
}
